#pragma once

#include <cstdint>
#include <vector>
#include <memory>
#include <chrono>
#include <string>
#include <string.h> // 为内存操作添加头文件
#include "MemoryPool.h" // 包含内存池头文件

namespace SeanNetwork {

// 消息优先级定义：0级最高，3级最低
enum class MessagePriority : uint8_t {
    Highest = 0,  // 最高优先级
    High = 1,     // 高优先级
    Normal = 2,   // 普通优先级
    Low = 3       // 低优先级
};

// 传输通道类型
enum class ChannelType : uint8_t {
    KCP = 0,
    TCP = 1
};

// 内存对齐宏，确保跨平台兼容性
#if defined(_MSC_VER)
#define SEAN_ALIGN(x) __declspec(align(x))
#elif defined(__GNUC__) || defined(__clang__)
#define SEAN_ALIGN(x) __attribute__((aligned(x)))
#else
#define SEAN_ALIGN(x)
#endif

// 消息头结构，内存16字节对齐优化访问性能
#pragma pack(push, 16)
struct SEAN_ALIGN(16) MessageHeader {
    uint32_t MessageLength;   // 消息总长度（包括头部）
    uint32_t MessageId;       // 消息ID
    uint8_t Priority;         // 优先级
    uint8_t Flags;            // 标志位
    uint16_t Reserved;        // 保留字段，用于内存对齐
    uint64_t Timestamp;       // 时间戳
    
    MessageHeader() : MessageLength(0), MessageId(0), 
        Priority(static_cast<uint8_t>(MessagePriority::Normal)), 
        Flags(0), Reserved(0), Timestamp(0) {}
};
#pragma pack(pop)

// 定义头部大小为静态常量
static const size_t MESSAGE_HEADER_SIZE = sizeof(MessageHeader);

// 预定义的标志位
enum MessageFlags : uint8_t {
    FLAG_NONE = 0x00,         // 无标志
    FLAG_COMPRESSED = 0x01,   // 压缩标志
    FLAG_ENCRYPTED = 0x02,    // 加密标志
    FLAG_REQUIRES_ACK = 0x04, // 需要确认标志
    FLAG_ACK = 0x08,          // 确认消息标志
    FLAG_KEEPALIVE = 0x10,    // 心跳包标志
    FLAG_FRAGMENT = 0x20,     // 分片消息标志
    FLAG_RELIABLE = 0x40,     // 可靠传输标志
};

// 缓冲区视图类，避免不必要的内存复制
class BufferView {
public:
    BufferView() : m_Data(nullptr), m_Size(0) {}
    
    BufferView(const uint8_t* data, size_t size) : m_Data(data), m_Size(size) {}
    
    BufferView(const std::vector<uint8_t>& data) : m_Data(data.data()), m_Size(data.size()) {}
    
    const uint8_t* data() const { return m_Data; }
    size_t size() const { return m_Size; }
    
    bool empty() const { return m_Size == 0 || m_Data == nullptr; }
    
private:
    const uint8_t* m_Data;
    size_t m_Size;
};

// 使用内存池分配器的向量类型
template<typename T>
using PoolVector = std::vector<T, MemoryPoolAllocator<T>>;

// 网络消息类
class NetworkMessage {
public:
    NetworkMessage();
    NetworkMessage(uint32_t messageId, MessagePriority priority = MessagePriority::Normal);
    ~NetworkMessage();
    
    // 禁用复制构造和赋值
    NetworkMessage(const NetworkMessage&) = delete;
    NetworkMessage& operator=(const NetworkMessage&) = delete;
    
    // 允许移动构造和赋值
    NetworkMessage(NetworkMessage&& other) noexcept;
    NetworkMessage& operator=(NetworkMessage&& other) noexcept;
    
    // 获取消息头
    const MessageHeader& GetHeader() const { return m_Header; }
    MessageHeader& GetHeader() { return m_Header; }
    
    // 获取消息体
    const uint8_t* GetBody() const { return m_Body.data(); }
    uint8_t* GetBody() { return m_Body.data(); }
    
    // 获取消息体长度
    size_t GetBodySize() const { return m_Body.size(); }
    
    // 获取完整消息长度（包括头部）
    size_t GetTotalSize() const { return MESSAGE_HEADER_SIZE + m_Body.size(); }
    
    // 设置消息内容
    void SetBody(const uint8_t* data, size_t size);
    void SetBody(const std::vector<uint8_t>& data);
    
    // 优化：设置消息内容（移动版本，避免复制）
    void SetBody(std::vector<uint8_t>&& data);
    
    // 获取消息体视图，避免不必要的复制
    BufferView GetBodyView() const { return BufferView(m_Body.data(), m_Body.size()); }
    
    // 设置消息ID
    void SetMessageId(uint32_t id) { m_Header.MessageId = id; }
    
    // 设置优先级
    void SetPriority(MessagePriority priority) { m_Header.Priority = static_cast<uint8_t>(priority); }
    
    // 设置标志位
    void SetFlag(MessageFlags flag) { m_Header.Flags |= flag; }
    void ClearFlag(MessageFlags flag) { m_Header.Flags &= ~flag; }
    bool HasFlag(MessageFlags flag) const { return (m_Header.Flags & flag) != 0; }
    
    // 更新时间戳
    void UpdateTimestamp();
    
    // 获取消息存活时间（毫秒）
    int64_t GetAliveTime() const;
    
    // 序列化为字节流
    PoolVector<uint8_t> Serialize() const;
    
    // 优化：序列化到已有缓冲区，避免不必要的分配
    size_t SerializeTo(uint8_t* buffer, size_t bufferSize) const;
    
    // 从字节流反序列化
    static std::shared_ptr<NetworkMessage> Deserialize(const uint8_t* data, size_t size);
    
    // 优化：从字节流反序列化（零复制版本）
    static std::shared_ptr<NetworkMessage> DeserializeZeroCopy(uint8_t* data, size_t size);
    
    // 重传计数
    void IncrementResendCount() { m_ResendCount++; }
    uint32_t GetResendCount() const { return m_ResendCount; }
    
    // 获取最后一次发送时间
    uint64_t GetLastSendTime() const { return m_LastSendTime; }
    void UpdateLastSendTime();
    
    // 内存分配器相关
    void* operator new(size_t size);
    void operator delete(void* ptr);
    
private:
    MessageHeader m_Header;                 // 消息头
    PoolVector<uint8_t> m_Body;            // 使用内存池分配器的消息体
    uint32_t m_ResendCount;                // 重传计数
    uint64_t m_LastSendTime;               // 最后一次发送时间（毫秒时间戳）
    uint64_t m_CreateTime;                 // 创建时间（毫秒时间戳）
    bool m_OwnBuffer;                      // 是否拥有消息体缓冲区（用于零复制）
};

// 获取当前时间毫秒时间戳
uint64_t GetCurrentTimeMillis();

} // namespace SeanNetwork
